home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 130_01 / disku.c < prev    next >
Encoding:
Text File  |  1985-03-09  |  17.0 KB  |  620 lines
  1. /*
  2.     DISK UTILITY PROGRAM
  3.  
  4.     Written by Richard Damon
  5.     Version 1.0 May 1980
  6.  
  7.     Revised by Bob Pasky
  8.     Version 2.0 July 1981
  9.     Version 2.4 Oct. 1981
  10.  
  11.     This program allows the operator to examine and modify
  12. a CPM diskette, either single density or Micromation's version of
  13. double density.
  14.  
  15.     The commands available in this package are :
  16.  
  17. Tn  set current track to n (0-76)
  18. Sn  set current sector to n (1-26/52)
  19. Ln  set current logical sector to n (0-25/51)
  20. Dn  set current disk number to n (0-3)
  21. Bn  set current track and sector to point to block n (0-F2)
  22. N   set current track and sector to next sector/block
  23.     next sector if last set command was for track or sector
  24.     next block if last set command was for block
  25. I   increment sector, if sector>max set to 1 and increment track
  26. R   read sector/block into buffer
  27. W   write sector/block from buffer
  28. P   print out contents of buffer, along with track/sector/block information
  29. Ea n n n n
  30.     edit buffer starting from location a filling with values n n n
  31. Aa "ccc..."
  32.     edit buffer starting from location a with ascii characters ccc...
  33. Fn  fill buffer with value n
  34. X   exit program
  35. M   print disk allocation map
  36. Cn  collate directory: n=0 orders by file type (from typtbl), n=1 by name
  37. ?   prints current track, sector, block info
  38. /   repeats last command string
  39.  
  40. Notes:
  41.     1)  Multiple commands may be specified on a line except for X and /
  42. which must be the only command on the line followed by return.
  43.     2)  Commands may be in upper or lower case letters
  44.     3)  Spaces are ignored except in the E command where they are used
  45.     as separaters for the numbers
  46.  
  47. Typical commands:
  48. d0t0s1rp    read in the track 0 sector 1 of disk 0 (Drive A) and print it
  49. e1A 4F 20 11    set buffer location 1A to 4F, 1B to 20, and 1C to 11.
  50. e0a 00w        set buffer location 0a to 0 and write buffer
  51.             Note no space after last data byte
  52. nrp        get next buffer and print it
  53.  
  54. Disk Allocation Map
  55.     The M command is designed to allow the directory blocks (blocks 0 and 1)
  56. to be printed out in a convient format. The directory is print out in the
  57. following format:
  58.  
  59.  Section 1:
  60.     The top half of the directory listing is a listing of the name
  61.     inforamtion of the directory entries.  Each line corresponds to 1 sector
  62.     of the directory.  A typical entry would be f=DISKTESTCOM/1 4c
  63.     The first letter is a code letter used to referance into section 2.
  64.     The equal sign indicats that the file exists, a star here indicates
  65.        that this entry is a deleted file.
  66.     Next comes the filename and extension.
  67.     The following /n is printed if this is other then the first extent 
  68.        (extent 0) of a file where n is the extent number of this entry.
  69.     The following number is the hex record count for this extent.
  70.  
  71.  Section 2:
  72.     The bottom half of the directory listing is a disk allocation map
  73.     showing which blocks are in use and by which file. Free blocks are
  74.     indicated by a dot while used blocks are marked by the file control
  75.     letter asigned to a file in section 1.  This listing has been blocked off
  76.     in groups of 8 and 16 to ease reading.
  77.  
  78. DIRECTORY SORTING
  79.  
  80.     Collating (sorting) the directory only places the sorted directory
  81. in the buffer. From there you can Write it back to the disk if desired,
  82. producing a sorted directory on the disk. The track, sector and block size
  83. are set up by Collate to their proper values for writing to the directory.
  84.  
  85.     Sorting can be performed alphabetically by the full name, type and
  86. extent, or grouped by type using a table within this program to sort by
  87. type -- within each type the files are ordered by name and extent. File
  88. types not found in the table are placed at the end, arranged by name, type
  89. and extent.
  90.  
  91. CPM FILE STRUCTURE
  92.  
  93.     To help the user of this program the following is a brief description
  94. of the format used in CPM. (Double density values are shown in parentheses.)
  95. The first 2 tracks of a disk are reserved for the bootstrap and the copy of
  96. the CPM operating system.  Tracks 2 through 76 store the data.  To speed up
  97. disk access CPM does not store consecutive data in consecutive sectors.
  98. Instead it uses every (8th or) 6th sector for data. Thus to read logical
  99. consecutive sectors you must read the sectors in the following order:
  100.  
  101. (single density only)
  102.  1 7 13 19 25 5 11 17 23 3 9 15 21 2 8 14 20 26 6 12 18 24 4 10 16 22
  103.  
  104. This interleaving is taken care of when reading in multiple sectors
  105. or when incrementing the disk address with the N command.  To simplify
  106. the disk allocation scheme the sectors are the collected into groups of
  107. (16 or) 8 sectors forming a (2k or) 1k block.  These blocks are numbered
  108. from 0 starting with the beginning of the directory -- track 2 sector 1.
  109. Block numbers range from 0 to F2 (hex).
  110.     The directory is organized to use (1 or) 2 blocks of storage -- 16
  111. sectors -- to store information on 64 file extensions.  A file extension
  112. is a part of a file up to 16k bytes long.  The directory entry for a file 
  113. extension is as follows:
  114.  
  115. byte  0   : file code : 0 if file exists, E5 if file is deleted
  116. byte  1- 8: file name : ascii representation of file name
  117. byte  9-11: file type : ascii representation of file type
  118. byte 12   : file ext  : binary number for extent number (0 to ?)
  119. byte 13,14: unused
  120. byte 15   : rec count : count of number of sectors in extent
  121. byte 16-31: map       : list of block numbers used by this extent
  122.  
  123. */
  124.  
  125. #include <bdscio.h>
  126.  
  127. #define MAXTYP    14    /* how many file types to sort on */
  128. #define SORTED    '~'    /* this may need changing for CP/M 2.x;
  129.                anything not seen in file_code is ok */
  130. #define DELETED    0xe5    /* ...anything except E5, of course */
  131. #define ESCAPE 0x1b
  132. #define STRDLM '"'
  133.  
  134. int    DEBUG;
  135. int    maxsecs, blocksecs, interval, typ, presdisk;
  136. char    density, buffer[2048], dir[2048], map[256];
  137. STATIC_char *typtbl[MAXTYP];
  138.  
  139. main(ac,av)
  140. int ac;
  141. char **av;
  142. {
  143.     int track, sector, disk, nsect, s, t, rs, rt, i, j, k, block;
  144.     char buff[80], prevbuff[80], *bufp, c, d, mc;
  145.  
  146.     disk=0;
  147.     track=rt=rs=0;
  148.     sector=1;
  149.     nsect=1;
  150.  
  151.     DEBUG = 0;
  152.     if (ac > 1 && (*av[1] == 'D')) DEBUG = 1;
  153. if(DEBUG)printf("\nDebug on...\n");
  154.  
  155.     presdisk = bdos(25,0);    /* find out which disk called from */
  156.  
  157.     typtbl[0]="COM";    /* change this table as desired */
  158.     typtbl[1]="SUB";
  159.     typtbl[2]="CRL";
  160.     typtbl[3]="CCC";
  161.     typtbl[4]="H  ";
  162.     typtbl[5]="C  ";
  163.     typtbl[6]="   ";
  164.     typtbl[7]="HEX";
  165.     typtbl[8]="DOC";
  166.     typtbl[9]="TXT";
  167.     typtbl[10]="BAK";
  168.     typtbl[11]="BRL";
  169.     typtbl[12]="TMP";
  170.     typtbl[13]="BAD";    /* note that the typtbl vector contains
  171.                    only pointers to the strings
  172.                         ********/
  173.  
  174.     printf("\n\t\tDisk Utility v 2.4\n");
  175.  
  176.     printf("Density on %c is Double\n", presdisk+65);
  177.     maxsecs = 52;
  178.     blocksecs = 16;
  179.     interval = 8;
  180.  
  181.     prevbuff[0] = '\0';    /* init last command string to nil */
  182.  
  183.     printf("Command? ");
  184.     while(tolower(*(bufp=gets(buff))) != 'x' || *(bufp+1) != '\0'){
  185.         if((*bufp == '/') && (*(bufp+1) == '\0'))
  186.             strcpy(buff,prevbuff);
  187.  
  188.         strcpy(prevbuff,buff);    /* save last command string */
  189.  
  190.         while((c=*bufp++) != '\0')
  191.         switch(toupper(c)){
  192.             case 'T' : track=getnum(&bufp,0,76,10,'T',track);
  193.                 nsect=1;
  194.                 break;
  195.  
  196.             case 'S' : sector=getnum(&bufp,1,maxsecs,10,'S',
  197.                             sector);
  198.                 nsect=1;
  199.                 break;
  200.  
  201.             case 'L' : s=getnum(&bufp,0,maxsecs-1,10,'L',
  202.                             tolog(sector));
  203.                 sector = tophys(s);
  204.                 nsect=1;
  205.                 break;
  206.  
  207.             case 'D' : disk=getnum(&bufp,0,3,10,'D',presdisk);
  208.                 do {
  209.                 printf("\nDensity of %c? (s/d) ", disk+65);
  210.                 density = tolower(getchar());
  211.                 } while (density != 's' && density != 'd');
  212.                 if (density == 's') {
  213.                     printf("ingle\n");
  214.                     maxsecs = 26;
  215.                     blocksecs = 8;
  216.                     interval = 6;
  217.                     }
  218.                 else    {
  219.                     printf("ouble\n");
  220.                     maxsecs = 52;
  221.                     blocksecs = 16;
  222.                     interval = 8;
  223.                     }
  224.                 break;
  225.  
  226.             case 'B' : block=getnum(&bufp,0,0xf2,16,'B',block);
  227.                 nsect=blocksecs;
  228.                 track=2 + block*blocksecs / maxsecs;
  229.                 s = block*blocksecs % maxsecs;
  230.                 sector = tophys(s);
  231.                 break;
  232.  
  233.             case 'N' : for(i=0;i<nsect;i++){
  234.                     sector = bumpsector(sector);
  235.                     if (sector == 1) track++;
  236.                     }
  237.                 break;
  238.  
  239.             case 'I' : sector+=nsect;
  240.                 if(sector>maxsecs){
  241.                     sector-=maxsecs;
  242.                     track++;
  243.                     }
  244.                 break;
  245.  
  246.             case 'R' : bios(9,disk);
  247.                 rt = t = track;
  248.                 rs = s = sector;
  249.                 if  (t < 2 && s > 26) {
  250.         printf("\n-- System tracks are not double density --");
  251.                     break;
  252.                     }
  253.                 for(i=0;i<nsect;i++){
  254.                     bios(10,t);
  255.                     bios(11,s);
  256.                     bios(12,&buffer[i*128]);
  257.                     bios(13);
  258.                     s = bumpsector(s);
  259.                     if(s==1)t++;
  260.                     }
  261.                 break;
  262.  
  263.             case 'W' : bios(9,disk);
  264.                 t=track;
  265.                 s=sector;
  266.                 if  (t < 2 && s > 26) {
  267.         printf("\n-- System tracks are not double density --");
  268.                     break;
  269.                     }
  270.                 if ((rs!=s) || (rt!=t)) {
  271.         printf("\n--Warning-- Track and/or sector have changed\
  272. since last read.\nDo you wish to continue? (y) ");
  273.                     if (tolower(getchar()) != 'y') {
  274.                     printf("...whew!");
  275.                     break;
  276.                     }
  277.                     else printf ("...ok, here goes...");
  278.                     }
  279.                 for(i=0;i<nsect;i++){
  280.                     bios(10,t);
  281.                     bios(11,s);
  282.                     bios(12,&buffer[i*128]);
  283.                     bios(14);
  284.                     s = bumpsector(s);
  285.                     if(s==1) t++;
  286.                     }
  287.                 break;
  288.  
  289.             case 'P' : /* display the values from read */
  290.                 if (!rs) {
  291.                     printf("\n -- empty --\n");
  292.                     break;
  293.                     }
  294.                 sector = rs; track = rt;
  295.                 block = (track-2)*maxsecs + tolog(sector);
  296.                 printf("track %d  sector %d ",track,sector);
  297.                 printf(" block %x.%d ",
  298.                     block/blocksecs,block%blocksecs);
  299.                 for(i=0;i<128*nsect;i+=16){
  300.                     printf("\n %4x  ",i);
  301.                     for(j=0;j<16;j++){
  302.                         printf("%2x ",buffer[i+j]);
  303.                         if(j%4 == 3) printf(" ");
  304.                         }
  305.                     for(j=0;j<16;j++){
  306.                         c=buffer[i+j]&0x7f;
  307.                         c=c<' '||c==0x7f ? '.' : c;
  308.                         putchar(c);
  309.                         }
  310.                     if(kbhit()) break;
  311.                     }
  312.                 putchar('\n');
  313.                 break;
  314.             case 'E' : i=getnum(&bufp,0,nsect*128-1,16,'E',0);
  315.                 while(*bufp==' '){
  316.                    printf("\n%02x: %02x --> ",i,buffer[i]);
  317.                    buffer[i] = getnum(&bufp,0,255,16,'E',0);
  318.                    printf("%02x",buffer[i++]);
  319.                    if(i>=nsect*128) break;
  320.                    }
  321.                 break;
  322.  
  323.             case 'A' : i=getnum(&bufp,0,nsect*128-1,16,'A',0);
  324.                 while (*bufp!=STRDLM && *bufp !='\0')
  325.                     bufp++;
  326.                 if (*bufp=='\0') {
  327.                     printf("\nno string");
  328.                     break;
  329.                     }
  330.                 bufp++;
  331.                 printf("\n%02x: <",i);
  332.                 while(*bufp!=STRDLM && *bufp!='\0') {
  333.                     buffer[i++] = *bufp;
  334.                     putchar(*bufp++);
  335.                     if(i>=nsect*128) {
  336.                         while(*bufp!=STRDLM
  337.                         && *bufp!='\0')
  338.                             bufp++;
  339.                         break;
  340.                         }
  341.                     }
  342.                 putchar('>');
  343.                 if(*bufp==STRDLM) bufp++;
  344.                 break;
  345.  
  346.             case 'F' : i=getnum(&bufp,0,255,16,'F',0);
  347.                 for(j=0;j<nsect*128;j++) buffer[j]=i;
  348.                 break;
  349.  
  350.             case 'M' : bios(9,disk);
  351.                 bios(10,2);
  352.                 s=1;
  353.                 for(i=0;i<16;i++){
  354.                     bios(11,s);
  355.                     bios(12,&dir[i*128]);
  356.                     bios(13);
  357.                     s = bumpsector(s);
  358.                     }
  359.                 setmem(&map,256,0);
  360.                 for(i=0;i<64;i++){
  361.                     if(i%4==0) putchar('\n');
  362.                     j=32*i;
  363.                     c=(dir[j]==0) ? '=' : '*';
  364.                     d=dir[j+12];
  365.                     mc=mapchar(i);
  366.                     if(d==DELETED){
  367.                         printf("%c%18s",mc,"");
  368.                         continue;
  369.                         }
  370.                     else
  371.                         dir[j+12]=0;
  372.                     printf("%c%c%s",mc,c,&dir[j+1]);
  373.                     if(d != 0) printf("/%x",d%0x10);
  374.                         else printf("  ");
  375.                     printf(" %2x ",dir[j+15]);
  376.                     if(c=='*')mc+=128;
  377.                     for(k=16;k<32 && dir[j+k];k++){
  378.                         d=dir[j+k];
  379.                         if(mc<128) map[d]=mc;
  380.                         }
  381.                     }
  382.                 for(i=0;i<0xf3;i++){
  383.                     if(i%64==0) putchar('\n');
  384.                     else if(i%16==0) printf("  ");
  385.                     else if(i%8==0) printf(" ");
  386.                     putchar(map[i] ? map[i] : '.');
  387.                     }
  388.                 putchar('\n');
  389.                 break;
  390.  
  391.             case 'C' : bios(9,disk);
  392.                 bios(10,2);
  393.                 s=1;
  394.                 for(i=0;i<16;i++){
  395.                     bios(11,s);
  396.                     bios(12,&dir[i*128]);
  397.                     bios(13);
  398.                     s = bumpsector(s);
  399.                     }
  400.                 /* set for writing: */
  401.                 rs=sector=1; rt=track=2;
  402.                 nsect=16;
  403.  
  404.                 typ=getnum(&bufp,0,1,10,'C',0);
  405.                 if (typ != 0) typ = MAXTYP;
  406.  
  407.                 for (i = 0; i < 2048; i += 32) {
  408.                    if((k = lowstring() * 32) >= 0) {
  409.                     putchar( i%128 ? ' ' : '\n');
  410.                     for (j = 0; j < 32; j++)
  411.                         buffer[i+j] = dir[k+j];
  412.                     dir[k] = SORTED;
  413.                 d = dir[k+12] + '0';
  414.                 dir[k+12] = 0; /* ensure name ends ok */
  415.                 printf("%2d=%s/%c  ",i/32, &dir[k+1], d);
  416.                     }
  417.                    else { for ( j = 0; j < 32; j++)
  418.                         buffer[i+j] = DELETED;
  419.                     }
  420.                    }
  421.                 printf("\nUse 'w' to re-write Directory\n");
  422.                 break;
  423.  
  424.             case ' ' : break;
  425.  
  426.             case '?' :
  427.                 block = (track-2)*maxsecs + tolog(sector);
  428.                 printf("track %d  sector %d ",track,sector);
  429.                 printf(" block %x.%d",block/blocksecs,
  430.                         block%blocksecs);
  431.                 break;
  432.  
  433.             default:
  434.                 printf("\nBad character <%c> ",c);
  435.                 printf("...remainder of line ignored.\n");
  436.                 *--bufp = '\0'; /* zap line here */
  437.                 strcpy(prevbuff,buff);    /* save zapped */
  438.  
  439.     printf("\nCommands are:\n");
  440.     printf("\nTn    set current track to n (0-76)");
  441.     printf("\nSn    set current sector to n (1-26/52)");
  442.     printf("\nLn    set current logical sector to n (0-25/51)");
  443.     printf("\nDn    set current disk number to n (0-3)");
  444.     printf("\nBx    set track & sector to point to block n (0-F2)");
  445.     printf("\nN    set track & sector to next sector/block");
  446.     printf("\nI    increment sector");
  447.     printf("\nR    read sector/block into buffer");
  448.     printf("\nW    write sector/block from buffer");
  449.     printf("\nP    print out contents of buffer");
  450.     printf("\nEa x x x...    edit buffer starting from location a");
  451.     printf("\nAa \"ccc...\"    edit buffer from a with character data");
  452.     printf("\nFn    Fill buffer with value n");
  453.     printf("\nM    print disk allocation map");
  454.     printf("\nCn    collate directory: 0=by type/name, 1=by name/type");
  455.     printf("\n?    print current track, sector, block numbers");
  456.     printf("\n/    repeat last command string");
  457.     printf("\nX    exit program");
  458.     printf("\n");
  459.                 break;
  460.             }
  461.         printf("\nCommand? ");
  462.         if(kbhit()) getchar();
  463.         }
  464.     bios(9,presdisk);    /* reset disk drive */
  465.     exit();
  466. }
  467.  
  468. bumpsector(s)
  469. int s;
  470. {
  471.     if (density == 's') {
  472.         if ((s = s+interval) > maxsecs) s -= maxsecs;
  473.         if (s == 2) s = 1;
  474.         else if (s == 1) s = 2;
  475.         return (s);
  476.         }
  477.     else
  478.         return (tophys(tolog(s) + 1));
  479. }
  480.  
  481. tophys(s)
  482. int s;
  483. {
  484.     while (s >= maxsecs) s -= maxsecs;
  485.     s =  1 + s/13 + (s*interval) % maxsecs;
  486.     if (DEBUG) printf("phys = %d",s);
  487.     return (s);
  488. }
  489.  
  490. tolog(s)
  491. int s;
  492. {
  493.     int ss, mu;
  494.  
  495.     while (s > maxsecs) s -= maxsecs;
  496.  
  497.     /**** comments apply to double density only ****/
  498.     /* adds 52 if s%8 is 5,6,7,8 to s then dividing by interval
  499.     ** giving number from 0 to 12.
  500.     ** sd: add 9 more if s%6 is 3 or 4; -- a wicked kludge
  501.     */
  502.     ss = (((s-1)%interval / 4) * maxsecs + s) / interval;
  503.     if (density == 's') ss += ( (s-1) % 6 % 4 / 2) * 9;
  504.  
  505.     /* to that add 13* s%4 giving number from 0 to 51    */
  506.     s = ss + (13 * ((s-1) % (maxsecs/13) ));
  507.     while (s > maxsecs) s -=maxsecs;
  508.  
  509. if(DEBUG) printf("\nlog = %d,",s);
  510.  
  511.     return (s);
  512. }
  513. getnum(pntr,low,high,base,cmndtype, current)
  514. int low, high, base, current;
  515. char **pntr, cmndtype;
  516. {
  517.     int number;
  518.     char c,buffer[50],*bp;
  519.     char *f1,*f2;
  520.  
  521.     number = 0;
  522.     while( **pntr== ' ') (*pntr)++ ;
  523.     while( (c=toupper(*(*pntr)++))>='0' && c<= '9' ||
  524.         base==16 && (c-=7) > '9' && c <= ('F'-7) )
  525.             number=base*number+c-'0';
  526.     (*pntr)--;
  527.     if (number<low || number>high){
  528.         if (base == 16) { f1 = "%c%x"; f2 = "%x and %x"; }
  529.         else {          f1 = "%c%d"; f2 = "%d and %d"; }
  530.         printf(f1, cmndtype, number);
  531.         printf(" is illegal value,\nEnter new number between ");
  532.         printf(f2, low, high);
  533.         printf(": ");
  534.         bp = gets(buffer);
  535.         if (bp[0] == ESCAPE) {
  536.             if (low<=current && current<=high)
  537.                 number = current;
  538.             else number = low;
  539.             printf("Default used: ");
  540.             printf(f1, cmndtype, number);
  541.         }
  542.         else number = getnum(&bp,low,high,base,cmndtype);
  543.         }
  544.     return (number);
  545. }
  546.  
  547. lowstring()
  548. {
  549.     int i,j;
  550.     char *dp;
  551.  
  552.     if (typ < MAXTYP) do {
  553.         for (i=0; i<64; i++)
  554.         if ((dir[i*32] == '\0') && (typcmp(&dir[i*32],typ) == 0))
  555.             break;
  556.        } while ((i == 64) && (++typ < MAXTYP));
  557.     if (typ == MAXTYP) {
  558.         for (i=0; i<64; i++)
  559.             if (dir[i*32] == '\0') break;
  560.         }
  561.  
  562. if(DEBUG)printf("\ntype: %d", typ);
  563.  
  564.     if (i == 64) return(-1);
  565.     if (i == 63) return(63);
  566.     for (j=i+1; j<64; j++) {
  567.         dp = &dir[j*32];
  568.         if ((*dp != DELETED) && (*dp != SORTED)) {
  569.         if ((typ < MAXTYP) && (typcmp(dp,typ) == 0))
  570.             if (namecmp(dp, &dir[i*32]) < 0 ) i = j;
  571.         if (typ == MAXTYP)
  572.             if (namecmp(dp, &dir[i*32]) < 0 ) i = j;
  573.         }
  574.         } /* end for */
  575.     return (i);
  576. }
  577.  
  578. namecmp(s1,s2)
  579. char *s1,*s2;
  580. {
  581. int i,j,k;
  582. char *t;
  583.  
  584. if(DEBUG)printf("\ns1 <%s>  s2 <%s>", s1+1, s2+1);
  585.     for (i=1; (s1[i] == s2[i]) && (i < 13); i++) ;
  586.     if (s1[i] == s2[i]) return 0;
  587.     if (s1[i] < s2[i]) return -1;
  588.     else return 1;
  589. }
  590.  
  591. typcmp(s1,typ)
  592. char *s1;
  593. int typ;
  594. {
  595.     int i;
  596.     char *t;
  597.  
  598.     t = typtbl[typ];
  599. /*if(DEBUG)printf("\ntypcmp: <%s> <%s>", &s1[9], t);*/
  600.     for (i=9; i<12; i++) if (s1[i] != *t++) break;
  601.     if (i==12) return 0;
  602.     else return -1;
  603. }
  604.  
  605. mapchar(i)
  606. char i;
  607. {    if(i<10) return (i+'0');
  608.     if(i<36) return (i-10+'a');
  609.     return (i-36+'A');
  610. }
  611.  
  612. putchar(c)
  613. char c;
  614. {
  615.     putch(c);
  616. }
  617.  
  618. /* the end */
  619.  
  620.